package study.datastructure.hashmap;/**
 * @program: datastructure
 * @author: lcy
 * @create: 2025-01-26 21:00
 */

import javax.lang.model.element.VariableElement;
import java.util.*;

/**
 * 2025/1/26,
 */


public class s2 {

    /**
     * 给定一个字符串 s ，请你找出其中不含有重复字符的 最长子串 的长度。
     * 滑动窗口 双指针
     * 右指针往右移动时，碰到重复元素 移除左指针，直到不包含重复元素，比较长度最大值
     *
     * @param s
     * @return
     */
    public int lenOfLongestSubstring(String s) {

        int len = 0;
        int maxLen = 0;
        int left = 0;
        int right = 0;
        HashSet<Character> set = new HashSet<>();

        while (right < s.length()) {
            if (!set.contains(s.charAt(right))) {

                len++;
                set.add(s.charAt(right));
                right++;
                if (len > maxLen) {
                    maxLen = len;
                }

            } else {
                while (set.contains(s.charAt(right))) {
                    set.remove(s.charAt(left));
                    left++;
                    len--;
                }
                set.add(s.charAt(right));
                len++;
                right++;
            }


        }
        return maxLen;


    }

    /**
     * 给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。
     *
     * @param strs
     * @return
     */
    public List<List<String>> groupAnagrams(String[] strs) {

        // [bat] ,[["bat"]],
        // [nat] ,[["nat","tan"]],
        // [ate] ,[["ate","eat","tea"]] b


        Map<String, List<String>> map = new HashMap<>();
        for (String str : strs) {
            char[] strCharArray = str.toCharArray();

            Arrays.sort(strCharArray);

            String strSorted = new String(strCharArray);

            List<String> stringList = map.getOrDefault(strSorted, new ArrayList<>());
            stringList.add(str);
            map.put(strSorted, stringList);
        }
        return new ArrayList<>(map.values());
    }

    /**
     * 给定一个整数数组 nums 判断是否包含重复的元素
     *
     * @param nums
     * @return
     */
    public boolean containsDuplicate(int[] nums) {

        if (nums == null || nums.length == 0) {
            return false;
        }

        HashSet<Integer> set = new HashSet<>();
        for (int num : nums) {
            if (!set.add(num)) {
                return true;
            }
        }
        return false;
    }


    /**
     * 其余每个元素均出现两次。找出那个只出现了一次的元素。
     *
     * @param nums
     * @return
     */
    public int singleNumber(int[] nums) {

        HashSet<Integer> set = new HashSet<>();
        for (int num : nums) {
            if (!set.add(num)) {
                set.remove(num);
            }
        }

        return set.iterator().next();


    }

    /**
     * 给定两个字符串 s 和 t ，编写一个函数来判断 t 是否是 s 的字母异位词。
     *
     * @param s
     * @param t
     * @return
     */
    public boolean isAnagram(String s, String t) {

        char[] sc = s.toCharArray();
        char[] tc = t.toCharArray();

        Arrays.sort(sc);
        Arrays.sort(tc);
        return Arrays.equals(sc, tc);

    }

    /**
     * 给定一个字符串 s ，请你找出其中不含有重复字符的 并返回它的索引 。如果不存在，则返回 -1 。
     *
     * @param s
     * @return
     */
    public int firstUniqChar(String s) {

        Map<Character, Integer> map = new HashMap<>();

        char[] sc = s.toCharArray();
        for (int i = 0; i < sc.length; i++) {
            map.put(sc[i], map.getOrDefault(sc[i], 0) + 1);
        }

        for (int i = 0; i < sc.length; i++) {
            if (map.get(sc[i]) == 1) {
                return i;
            }
        }
        return -1;

    }

    /**
     * 给你一个字符串 paragraph 和一个表示禁用词的字符串数组 banned ，返回出现频率最高的非禁用词。题目数据 保证 至少存在一个非禁用词，且答案 唯一
     * paragraph = "Bob hit a ball, the hit BALL flew far after it was hit.", banned = ["hit"]
     * 输出："ball"
     * 解释：
     * "hit" 出现了 3 次，但它是禁用词。
     * "ball" 出现了两次（没有其他单词出现这么多次），因此它是段落中出现频率最高的非禁用词。
     * 请注意，段落中的单词不区分大小写，
     * 标点符号会被忽略（即使它们紧挨着单词，如 "ball,"），
     * 并且尽管 "hit" 出现的次数更多，但它不能作为答案，因为它是禁用词。
     * <p>
     * SET <ban></ban> : hit  aaa ....
     * <p>
     * maxFreq = 0
     * <p>
     * ans = ""
     * <p>
     * bob 1
     * a 1
     * ball  2
     *
     * @param paragraph
     * @param banned
     * @return
     */

    public String mostCommonWord(String paragraph, String[] banned) {

        //禁用词集合
        Set<String> banSet = new HashSet<>(Arrays.asList(banned));


        //统计词频
        String result = "";
        Integer freq = 0;
        Map<String, Integer> mapFreq = new HashMap<>();
        StringBuffer sb = new StringBuffer();
        int length = paragraph.length();
        for (int i = 0; i <= length; i++) {

            if (i < length && Character.isLetter(paragraph.charAt(i))) {
                sb.append(Character.toLowerCase(paragraph.charAt(i)));
            } else if (sb.length() > 0) {
                String word = sb.toString();
                if (!banSet.contains(word)) {
                    mapFreq.put(word, mapFreq.getOrDefault(word, 0) + 1);
                    sb.setLength(0);
                    Integer freq1 = mapFreq.get(word);
                    if (freq1 > freq) {
                        freq = freq1;
                        result = word;
                    }
                } else {
                    sb.setLength(0);
                }
            }
        }
        return result;
    }

    public static void main(String[] args) {
        s2 s2 = new s2();
        System.out.println(s2.mostCommonWord("Bob", new String[]{}));

    }
}
